The development of software applications is a very critical activity; the problem is particular acute for large software applications, especially when they are intended to run in heterogeneous network environments or have multi-layer architectures.
For this purpose, several modeling tools are available to aid formalizing the developing process. Generally, a modeling tool is used to define a series of models (for example, of the UML type); each model consists of an abstraction, which provides a simplified representation of a real aspect of the software application. In this way, it is possible to visualize, assess and communicate the software application before its actual implementation (so as to reduce the risks of the corresponding development). Typically, the modeling tool also provides an Integrated Development Environment (IDE), which facilitates the generation of the corresponding code; in this way, the software application can be created and maintained in a very simple, safe and time effective manner. An example of commercial modeling tool is the “Rational Rose” by IBM Corporation.
Moreover, several software engineering techniques have also been proposed to master the inherent complexity of the developing process. Particularly, a consolidated practice is of decomposing the software application into multiple modules. Each module consists of an independent part of the software application serving a specific purpose; the different modules cooperate among them to produce the overall behavior of the software application.
In this way, preexisting modules may be reused for developing the software application (rather than creating them ex-novo). The possibility of assembling reused modules reduces the developing time and cost; moreover, the reused modules are generally largely tested, so that their exploitation results in software applications that are more robust, fault tolerant and reliable. An evolution of the above-described technique consists of providing modules that can be shared among multiple software applications; in this way, a single copy of each shared module is used and maintained for multiple software applications, with a corresponding reduction in system resource consumption.
However, no support is provided by the existing modeling tools for managing the task of decomposing the software application efficiently into suitable modules. Therefore, the definition of the modules of the software application still remains a substantial manual activity, which is mainly based on an investigation process requiring a heavy human intervention; as a consequence, the obtained results strongly depend on personal skills, and in any case are not repeatable and prone to errors.
The above-mentioned drawbacks adversely affect the quality of the development process. Indeed, it is not possible to ascertain the actual degree of modularity of the software application (apart from a mere feeling based on personal experiences). As a result, the software application may result under engineered when it includes a too low number of modules (which do not allow exploiting the advantages of the above-mentioned modular approach); conversely, the software application may result over engineered when it includes a too high number of modules (which overload the software application without any tangible advantage). Moreover, this may lead to problems in the exploitation of the software applications—such as for the management of their (installation and/or runtime) prerequisites, footprint issues, and the like.